package demo03_collection

import java.util.ArrayList
import scala.collection.mutable
import scala.collection.mutable.ListBuffer

object Demo02_mutableCollection {

  /**
   * 不可变集合 List 对应的可以变集合 Buffer/ListBuffer
   */
  def createListBuffer() = {
    val listBuffer: ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5)
    listBuffer.append(100,200,300)
    println(listBuffer)
  }

  /**
   * 不可变集合 Set/HashSet 对应的可以变集合 Set/HashSet
   * 由于可变与不可变的类是一样的，使用包名.类名会更加容易理解
   */
  def createSet() = {
    val hashSet: mutable.HashSet[Int] = mutable.HashSet(3, 4, 5, 4, 3, 2, 4, 5)
    hashSet.add(10)
    hashSet.add(20)
    hashSet.add(30)
    println(hashSet)
  }

  /**
   * 不可变集合 Map/HashMap 对应的可以变集合 Map/HashMap
   * 由于可变与不可变的类是一样的，使用包名.类名会更加容易理解
   */
  def createMap() = {
    val hashMap: mutable.HashMap[String, Any] = mutable.HashMap(("name", "tom"), "age" -> 20, "name" -> "jerry")
    hashMap.put("gender","boy")
    println(hashMap)
  }

  /**
   * 通过 newBuilder 的形式创建集合
   * 所有的集合类型(可变和不可变)都可以通过调用 newBuilder 来创建 Builder 类型的变量
   * 通过 Builder 类型对象调用 result() 可以获取相应类型的对象
   */
  def createCollectionByNewBuilder() = {

    val listBuffer = ListBuffer.newBuilder[Int]
    listBuffer.+=(100)
    listBuffer.+=(200)
    listBuffer.+=(300)
    listBuffer.+=(100)
    println(listBuffer.result())
    listBuffer.clear()
    println(listBuffer.result())

    val hashSet = mutable.HashSet.newBuilder[Int]
    hashSet.+=(100)
    hashSet.+=(200)
    hashSet.+=(300)
    hashSet.+=(100)
    println(hashSet.result())

    val listBuilder = List.newBuilder[Int]
    listBuilder.+=(100)
    listBuilder.+=(200)
    listBuilder.+=(300)
    listBuilder.+=(100)
    val list:List[Int] = listBuilder.result()
  }

  /**
   * 把不可变的　List 转成 Set/Map
   */
  def transformListToOther() = {

    val list:List[Int] = List(3, 4, 5, 3, 2, 4, 5, 2)
    println(list)

    val set:Set[Int] = list.toSet
    println(set)

    val listKV:List[(String,String)] = List(("name","tom"),("age","20"),"gender"->"男")
    val map:Map[String,String] = listKV.toMap
    println(map)

  }

  /**
   * 把不可变的　Set 转成 List/Map
   */
  def transformSetToOther() = {

    val set:Set[Int] = Set(3, 4, 5, 3, 2, 4, 5, 2)
    println(set)

    val list:List[Int] = set.toList
    println(list)

    val setKV:Set[(String,String)] = Set(("name","tom"),("age","20"),"gender"->"男")
    val map:Map[String,String] = setKV.toMap
    println(map)

  }

  /**
   * 把不可变的　Map 转成 List/Set
   */
  def transformMapToOther() = {

    val map: Map[String, String] = Map(("name", "tom"), ("age", "20"), "gender" -> "男")
    println(map)

    val list:List[(String,String)] = map.toList
    println(list)

    val set:Set[(String,String)] = map.toSet
    println(set)

  }

  /**
   * 把集合转成字符串
   */
  def transformToString() = {
    //1.toString 把集合的形式完整的转成字符串
    val list: List[Int] = List(1, 2, 3, 4, 5)
    val listStr:String = list.toString()
    println(listStr)
    listStr
      .replace("List(","")
      .replace(")","")
      .split(",\\s*")
      .foreach(println)

    //2.只把元素获取出来，无参表示所有元素无缝连接，一个参数表示所有元素用参数连接，三个参数表示所有元素用参数连接字符串的首尾也有指定内容
    val str1:String = list.mkString
    println(str1)
    val str2:String = list.mkString("#")
    println(str2)
    val str3:String = list.mkString("^-^","#","^+^")
    println(str3)
  }

  /**
   * 把不可变集合转成可变集合
   * 适用条件：如果对对象的类型没有严格要求，只要求功能可以修改内容的情况下就适合使用 toBuffer
   *         这种形式无需导包，用起来更加的方便
   *
   */
  def transformImmutableToMutable() = {
    val list: List[Int] = List(1, 2, 3, 4, 5)
    val set:Set[Int] = Set(1,2,3,4,5)
    val map: Map[String, Any] = Map(("name", "tom"), ("age", 20))

    val listBuffer:mutable.Buffer[Int] = list.toBuffer
    val setBuffer:mutable.Buffer[Int] = set.toBuffer
    val mapBuffer:mutable.Buffer[(String,Any)] = map.toBuffer

    listBuffer.append(100)
    setBuffer.append(100)
    mapBuffer.append(("gender","girl"))

    println(listBuffer)
    println(setBuffer)
    println(mapBuffer)

  }

  /**
   * 把可变集合转成不可变集合
   *  不管原类型是什么，只要数据格式允许，都可以转成 list set map
   */
  def transformMutableToImmutable() = {

    val listBuffer:mutable.ListBuffer[Int] = ListBuffer(1,2,3,4,5,4,3,2)
    val set:mutable.Set[Int] = mutable.Set(1,2,3,4,5)
    val map: mutable.Map[String, Any] = mutable.Map(("name", "tom"), ("age", 20))

    val list2List:List[Int] = listBuffer.toList
    val list2Set:Set[Int] = listBuffer.toSet

    val set2List:List[Int] = set.toList
    val set2Set:Set[Int] = set.toSet

    val map2Map:Map[String,Any] = map.toMap
    val map2List:List[(String,Any)] = map.toList
    val map2Set:Set[(String,Any)] = map.toSet
  }

  /**
   * scala 与 Java 集合之间的转换
   */
  def transformScalaAndJava() = {

    import collection.JavaConverters._

    val list_scala: List[Int] = List(1, 2, 3, 4, 5)
    val list_scala2Java:java.util.List[Int] = list_scala.asJava

    val list_java:java.util.List[Int] = new ArrayList[Int]()
    val list_java2Scala:List[Int] = list_java.asScala.toList

  }

  def main(args: Array[String]): Unit = {
//    createListBuffer()
//    createSet()
//    createMap()
//    createCollectionByNewBuilder()
//    transformListToOther()
//    transformSetToOther()
//    transformMapToOther()
//    transformToString()
//    transformImmutableToMutable()
    transformMutableToImmutable()
  }

}
